home *** CD-ROM | disk | FTP | other *** search
/ Aminet 40 / Aminet 40 (2000)(Schatztruhe)[!][Dec 2000].iso / Aminet / dev / gui / MultiDesktop.lha / MultiDesktop / win.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-03-27  |  28.7 KB  |  1,292 lines
  1. /* Fenster-Verwaltung */
  2. #include "multiwindows.h"
  3.  
  4. extern struct ExecBase         *SysBase;
  5. extern struct MultiWindowsBase *MultiWindowsBase;
  6.  
  7. BOOL         UnIconifyWindow();
  8. void         DrawFrame();
  9. void         UpdateFrames();
  10. extern UWORD INewX(),INewY(),INewWidth(),INewHeight();
  11.  
  12. /* ---- Neues Fenster öffnen */
  13. BOOL CreateWindow(windowID,titleID,x,y,w,h,flags,screenID,special)
  14.  UBYTE             windowID;
  15.  ULONG             titleID;
  16.  UWORD             x,y,w,h;
  17.  UWORD             flags;
  18.  UBYTE             screenID;
  19.  struct CWSpecial *special;
  20. {
  21.  BOOL                     locked;
  22.  UWORD                    nx,ny;
  23.  struct MultiWindowsUser *mw;
  24.  struct ExtNewWindow     *nw;
  25.  struct Screen           *scr;
  26.  struct ScreenEntry      *se;
  27.  struct WindowEntry      *we;
  28.  struct DimensionInfo     di;
  29.  
  30.  /* ---- ID-Angaben prüfen und PubScreen sperren ------------------- */
  31.  USER;
  32.  
  33.  if(windowID>MAXWINDOWS)
  34.   { ErrorL(1000,"CreateWindow():\nInvalid WindowID!");
  35.     return(FALSE); }
  36.  if(mw->WindowList[windowID]!=NULL)
  37.   { ErrorL(1003,"CreateWindow():\nWindowID already used!");
  38.     return(FALSE); }
  39.  if( (screenID==SCREENID_WORKBENCH) ||
  40.      ((screenID<=MAXSCREENS)&&(mw->ScreenList[screenID]==NULL)) )
  41.   {
  42.    scr=LockPubScreen(NULL);
  43.    if(scr==NULL)
  44.     { ErrorL(1004,"CreateWindow():\nUnable to lock public screen!");
  45.       return(FALSE); }
  46.    locked=TRUE;
  47.    se=NULL;
  48.   }
  49.  else
  50.   {
  51.    if(screenID>MAXSCREENS)
  52.     { ErrorL(1001,"CreateWindow():\nInvalid ScreenID!");
  53.       return(FALSE); }
  54.    se=mw->ScreenList[screenID];
  55.    if(se==NULL)
  56.     { ErrorL(1002,"CreateWindow():\nNo screen with this ScreenID available!");
  57.       return(FALSE); }
  58.    scr=se->Screen;
  59.    locked=FALSE;
  60.   }
  61.  
  62.  /* ---- WindowEntry erstellen ------------------------------------- */
  63.  we=ALLOC1(sizeof(struct WindowEntry));
  64.  if(we==NULL)
  65.    { if(locked) UnlockPubScreen(NULL,scr);
  66.      NoMemory();
  67.      return(FALSE); }
  68.  
  69.  /* ---- AspectX/Y-Berechnung -------------------------------------- */
  70.  GetDisplayInfoData(NULL,&di,sizeof(struct DimensionInfo),DTAG_DIMS,GetVPModeID(&scr->ViewPort));
  71.  nx=di.Nominal.MaxX+1;
  72.  ny=di.Nominal.MaxY+1;
  73.  we->AspectX=((FLOAT)nx/4.0) / ((FLOAT)ny/3.0);
  74.  we->AspectY=((FLOAT)ny/3.0) / ((FLOAT)nx/4.0);
  75.  
  76.  /* ---- NewWindow-Struktur initialisieren ------------------------- */
  77.  nw=&we->NewWindow;
  78.  nw->LeftEdge=x;
  79.  nw->TopEdge=y;
  80.  nw->Width=w;
  81.  nw->Height=h;
  82.  nw->Title=FindID(mw->Catalog,titleID);
  83.  nw->Screen=scr;
  84.  nw->Flags=REPORTMOUSE|ACTIVATE|WFLG_NW_EXTENDED;
  85.  if(flags & CW_INACTIVATE) nw->Flags &= (0xffff-ACTIVATE);
  86.  if(flags & CW_DRAG) nw->Flags |= WINDOWDRAG;
  87.  if(flags & CW_DEPTH) nw->Flags |= WINDOWDEPTH;
  88.  if(flags & CW_SIZE) nw->Flags |= WINDOWSIZING;
  89.  if(flags & CW_CLOSE) nw->Flags |= WINDOWCLOSE;
  90.  if(flags & CW_BORDERLESS) nw->Flags |= BORDERLESS;
  91.  nw->IDCMPFlags=MXIDCMP|SCROLLERIDCMP|STRINGIDCMP|INTEGERIDCMP|SLIDERIDCMP|STRINGIDCMP|LISTVIEWIDCMP|BUTTONIDCMP|CYCLEIDCMP;
  92.  nw->IDCMPFlags|=INACTIVEWINDOW|ACTIVEWINDOW|CLOSEWINDOW|NEWSIZE|GADGETUP|GADGETDOWN|MENUPICK|RAWKEY|VANILLAKEY|REFRESHWINDOW|MOUSEMOVE|NEWPREFS;
  93.  if(mw->HasMenuHelp) nw->IDCMPFlags |= MENUVERIFY;
  94.  nw->DetailPen=0;
  95.  nw->BlockPen=1;
  96.  nw->MinWidth=nw->Width;
  97.  nw->MinHeight=nw->Height;
  98.  nw->MaxWidth=scr->Width;
  99.  nw->MaxHeight=scr->Height;
  100.  nw->Type=CUSTOMSCREEN;
  101.  nw->CheckMark=NULL;
  102.  nw->FirstGadget=NULL;
  103.  nw->BitMap=NULL;
  104.  
  105.  /* ---- ExtNewWindow initialisieren ------------------------------- */
  106.  nw->Extension=&we->TagList;
  107.  we->WindowID=windowID;
  108.  we->TagList[2].ti_Tag=WA_AutoAdjust;
  109.  we->TagList[2].ti_Data=TRUE;
  110.  we->TagList[1].ti_Tag=WA_InnerWidth;
  111.  we->TagList[1].ti_Data=(UWORD)((FLOAT)w*mw->FactorX);
  112.  we->TagList[0].ti_Tag=WA_InnerHeight;
  113.  we->TagList[0].ti_Data=(UWORD)((FLOAT)h*mw->FactorY);
  114.  we->TagList[3].ti_Tag=TAG_DONE;
  115.  
  116.  /* ---- Fenster öffnen -------------------------------------------- */
  117.  we->Window=OpenWindow(nw);
  118.  if(we->Window==NULL)
  119.   {
  120.    { if(locked) UnlockPubScreen(NULL,scr);
  121.      FREE1(we);
  122.      ErrorL(1005,"CreateWindow():\nUnable to open window!");
  123.      return(FALSE); }
  124.   }
  125.  
  126.  /* ---- TagList um 3 Einträge erhöhen (für Iconify) --------------- */
  127.  nw->Extension=&we->TagList[3];  /* InnerWidth/Height, AutoAdjust  */
  128.                                  /* sollen bei UnIconify wegfallen */
  129.  
  130.  /* ---- WindowEntry-Struktur initialisieren ----------------------- */
  131.  NewList(&we->GadgetList);
  132.  NewList(&we->FrameList);
  133.  we->WindowFlags=flags;
  134.  we->OWidth=w;
  135.  we->OHeight=h;
  136.  we->Iconify=FALSE;
  137.  we->UserPort=we->Window->UserPort;
  138.  we->RastPort=we->Window->RPort;
  139.  we->ViewPort=ViewPortAddress(we->Window);
  140.  we->DrawInfo=GetScreenDrawInfo(scr);
  141.  we->VisualInfo=GetVisualInfoA(scr,NULL);
  142.  we->ScreenEntry=se;
  143.  we->TextFont=mw->TextFont;
  144.  
  145.  we->Width=we->Window->Width;
  146.  we->Height=we->Window->Height;
  147.  we->FactorX=(FLOAT)we->Width/(FLOAT)w;
  148.  we->FactorY= (FLOAT)we->Height/(FLOAT)h;
  149.  we->Layer=we->Window->WLayer;
  150.  we->LayerInfo=&scr->LayerInfo;
  151.  we->ColorMap=scr->ViewPort.ColorMap;
  152.  we->BitMap=scr->RastPort.BitMap;
  153.  we->Screen=scr;
  154.  we->Window->UserData=we;
  155.  we->WindowNode.ln_Name=nw->Title;
  156.  
  157.  if(locked) we->PubScreenLock=TRUE; else we->PubScreenLock=FALSE;
  158.  if((we->DrawInfo==NULL)||(we->VisualInfo==NULL))
  159.   {
  160.     { CloseWindow(we->Window);
  161.       if(we->VisualInfo) FreeVisualInfo(we->VisualInfo);
  162.       if(we->DrawInfo) FreeScreenDrawInfo(we->DrawInfo);
  163.       if(locked) UnlockPubScreen(NULL,scr);
  164.       FREE1(we);
  165.       NoMemory();
  166.       return(FALSE); }
  167.   }
  168.  
  169.  SetFont(we->RastPort,mw->TextFont);
  170.  SetAPen(we->RastPort,we->DrawInfo->dri_Pens[TEXTPEN]);
  171.  WindowLimits(we->Window,we->Width,we->Height,scr->Width,scr->Height);
  172.  CalcInnerSize(we);
  173.  
  174.  we->TextSpacing=we->RastPort->TxSpacing;
  175.  
  176.  if(flags & CW_INITGFX)
  177.   {
  178.    CreateTmpRas(we);
  179.    CreateAreaInfo(we,200);
  180.   }
  181.  
  182.  /* ---- Window in WindowList einhängen ---------------------------- */
  183.  Forbid();
  184.  mw->WindowList[windowID]=we;
  185.  if(!(flags & CW_INACTIVATE))
  186.   {
  187.    mw->ActiveWindowID=windowID;
  188.    mw->ActiveWindow=we;
  189.   }
  190.  if(se!=NULL)
  191.    AddHead(&se->WindowList,we);
  192.  Permit();
  193.  return(TRUE);
  194. }
  195.  
  196. /* ---- WindowEntry für ID ermitteln */
  197. struct WindowEntry *FindWindowEntry(windowID)
  198.  UBYTE windowID;
  199. {
  200.  struct MultiWindowsUser  *mw;
  201.  struct WindowEntry       *we;
  202.  
  203.  USER;
  204.  if(windowID>MAXWINDOWS)
  205.   { ErrorL(1006,"FindWindowEntry():\nInvalid WindowID!");
  206.     return(NULL); }
  207.  
  208.  we=mw->WindowList[windowID];
  209.  if(we==NULL)
  210.   { ErrorL(1007,"FindWindowEntry():\nNo window with this WindowID available!");
  211.     return(NULL); }
  212.  return(we);
  213. }
  214.  
  215. /* ---- Prüfen, ob WindowID gültig ist */
  216. BOOL CheckWindowID(windowID)
  217.  UBYTE windowID;
  218. {
  219.  struct MultiWindowsUser  *mw;
  220.  
  221.  USER;
  222.  if(windowID<=MAXWINDOWS)
  223.   { if(mw->WindowList[windowID]!=NULL) return(TRUE); }
  224.  return(FALSE);
  225. }
  226.  
  227. /* ---- Fenster schließen */
  228. void DeleteWindow(windowID)
  229.  UBYTE windowID;
  230. {
  231.  struct MultiWindowsUser *mw;
  232.  struct WindowEntry      *we;
  233.  struct Node             *node;
  234.  struct MWGadget         *gad;
  235.  struct Gadget           *g;
  236.  struct ListviewData     *ld;
  237.  struct IconData         *iconData;
  238.  struct ImageData        *imageData;
  239.  int                      i;
  240.  
  241.  USER;
  242.  if((CheckWindowID(windowID))==FALSE) return;
  243.  we=FindWindowEntry(windowID);
  244.  if(we)
  245.   {
  246.    GadHelpClose(we);
  247.    /* ---- Fenster aus WindowList entfernen --------------------- */
  248.    Forbid();
  249.    mw->WindowList[windowID]=NULL;
  250.    if(mw->ActiveWindow==we->Window)
  251.     {
  252.      mw->ActiveWindow=NULL;
  253.      mw->ActiveWindowID=-1;
  254.     }
  255.    if(we->ScreenEntry) Remove(we);
  256.    Permit();
  257.  
  258.    if(we->Iconify)
  259.     {
  260.      /* ---- Fenster ist ikonifiziert --------------------------- */
  261.      if(we->AppIcon) DeleteAppObject(we->AppIcon);
  262.      if(we->AppMenuItem) DeleteAppObject(we->AppMenuItem);
  263.     }
  264.    else
  265.     {
  266.      /* ---- Fenster ist geöffnet ------------------------------- */
  267.      if(we->Window)
  268.       {
  269.        ClearMenuStrip(we->Window);
  270.        ClearPointer(we->Window);
  271.        CloseWindow(we->Window);
  272.        SetPointerColors();
  273.        DisposeMenu(we);
  274.       }
  275.     }
  276.  
  277.     /* ---- Strukturen freigeben -------------------------------- */
  278.     if(we->PubScreenLock) UnlockPubScreen(NULL,we->Screen);
  279.     FreeVisualInfo(we->VisualInfo);
  280.     FreeScreenDrawInfo(we->Screen,we->DrawInfo);
  281.     if(we->SysWPAddress) UnLoadWallpaper(we->SysWPAddress);
  282.     if(we->SysPOAddress) UnLoadPointer(we->SysPOAddress);
  283.  
  284.     we->RastPort=NULL; /* Wichtig für DeleteTmpRas()/DeleteAreaInfo() !!! */
  285.     if(we->TmpRasCount>0)
  286.      {
  287.       we->TmpRasCount=1;
  288.       DeleteTmpRas(we);
  289.      }
  290.     DeleteAreaInfo(we);
  291.  
  292.     if(we->WindowFont)
  293.      {
  294.       Forbid();
  295.       we->WindowFont->tf_Accessors--;
  296.       Permit();
  297.      }
  298.  
  299.     /* ---- Schalter entfernen ---------------------------------- */
  300.     for(node=we->GadgetList.lh_Head;node!=&we->GadgetList.lh_Tail;node=node->ln_Succ)
  301.      {
  302.       gad=node;
  303.       switch(gad->Type)
  304.        {
  305.         case MWGAD_GADTOOLS:
  306.           if(gad->Gadget)
  307.             FreeGList(gad->Gadget,gad->GadgetCount);
  308.           if(gad->Kind==LISTVIEW_KIND)
  309.            {
  310.             ld=gad->ExtData;
  311.             FreeMemory(&ld->Remember);
  312.            }
  313.          break;
  314.         case MWGAD_SPECIAL:
  315.           switch(gad->Kind)
  316.            {
  317.             case ICON_KIND:
  318.               iconData=gad->ExtData;
  319.               if(iconData->Icon) FreeDiskObject(iconData->Icon);
  320.              break;
  321.             case IMAGE_KIND:
  322.               imageData=gad->ExtData;
  323.               if(imageData->Image) DisposeObject(imageData->Image);
  324.               if(imageData->Gadget) DisposeObject(imageData->Gadget);
  325.              break;
  326.            }
  327.          break;
  328.        }
  329.       FreeMemory(&gad->Remember);
  330.      }
  331.  
  332.    /* ---- Remember und WindowEntry freigeben ------------------- */
  333.    if(we->Remember.FirstRemember) FreeMemory(&we->Remember);
  334.    FREE1(we);
  335.   }
  336. }
  337.  
  338. /* ---- Fenster aktivieren (INTERN, ohne GadHelpClose) */
  339. BYTE ActWin(windowID)
  340.  UBYTE windowID;
  341. {
  342.  BYTE                     oldID;
  343.  struct MultiWindowsUser *mw;
  344.  struct WindowEntry      *we;
  345.  
  346.  USER;
  347.  if(windowID!=-1)
  348.   {
  349.    we=FindWindowEntry(windowID);
  350.    if(we)
  351.     {
  352.      if(we->Iconify) UnIconifyWindow(windowID);
  353.  
  354.      Forbid();
  355.      oldID=mw->ActiveWindowID;
  356.      mw->ActiveWindow=we;
  357.      mw->ActiveWindowID=windowID;
  358.      Permit();
  359.     }
  360.   }
  361.  else
  362.   {
  363.    oldID=mw->ActiveWindowID;
  364.    mw->ActiveWindow=NULL;
  365.    mw->ActiveWindowID=-1;
  366.   }
  367.  return(oldID);
  368. }
  369.  
  370. /* ---- Fenster ikonifizieren */
  371. BOOL IconifyWindow(windowID,flags)
  372.  UBYTE windowID;
  373.  UWORD flags;
  374. {
  375.  struct MultiWindowsUser *mw;
  376.  struct WindowEntry      *we;
  377.  struct NewWindow        *nw;
  378.  struct Window           *win;
  379.  struct RastPort         *rp;
  380.  
  381.  USER;
  382.  we=FindWindowEntry(windowID);
  383.  if((we)&&(!(we->Iconify)))
  384.   {
  385.    GadHelpClose(we);
  386.  
  387.    if(flags & IF_APPICON)
  388.     {
  389.      we->AppIcon=CreateAppObject(-1L,AOT_ICON,"AppIcon",OT_WINDOWENTRY,we);
  390.      if(we->AppIcon==NULL)
  391.        return(FALSE);
  392.     }
  393.  
  394.    if(flags & IF_APPMENU)
  395.     {
  396.      we->AppMenuItem=CreateAppObject(-1L,AOT_MENUITEM,"AppMenuItem",OT_WINDOWENTRY,we);
  397.      if(we->AppMenuItem==NULL)
  398.       {
  399.        if(we->AppIcon) DeleteAppObject(we->AppIcon);
  400.        we->AppIcon=NULL;
  401.        return(FALSE);
  402.       }
  403.     }
  404.  
  405.    nw=&we->NewWindow;
  406.    win=we->Window;
  407.    rp=we->Window->RPort;
  408.  
  409.    nw->Title=win->Title;
  410.    nw->LeftEdge=win->LeftEdge;
  411.    nw->TopEdge=win->TopEdge;
  412.    nw->Width=win->Width;
  413.    nw->Height=win->Height;
  414.    nw->Flags=win->Flags;
  415.    nw->IDCMPFlags=win->IDCMPFlags;
  416.    nw->MinWidth=win->MinWidth;
  417.    nw->MinHeight=win->MinHeight;
  418.    nw->MaxWidth=win->MaxWidth;
  419.    nw->MaxHeight=win->MaxHeight;
  420.    nw->DetailPen=win->DetailPen;
  421.    nw->BlockPen=win->BlockPen;
  422.    nw->Type=CUSTOMSCREEN;
  423.    nw->Screen=win->WScreen;
  424.    nw->CheckMark=NULL;
  425.    nw->FirstGadget=NULL;
  426.    nw->BitMap=NULL;
  427.    CopyMemQuick(rp,&we->IRastPort,sizeof(struct RastPort));
  428.  
  429.    we->Window=NULL;
  430.    we->RastPort=NULL;
  431.    we->UserPort=NULL;
  432.    we->ViewPort=NULL;
  433.    we->Screen=NULL;
  434.    we->LayerInfo=NULL;
  435.    we->ColorMap=NULL;
  436.    we->BitMap=NULL;
  437.    we->Layer=NULL;
  438.    we->Iconify=TRUE;
  439.  
  440.    SetPointerColors();
  441.    ClearPointer(win);
  442.    ClearMenuStrip(win);
  443.    CloseWindow(win);
  444.  
  445.    if(we->VisualInfo) FreeVisualInfo(we->VisualInfo);
  446.    if(we->DrawInfo) FreeScreenDrawInfo(we->DrawInfo);
  447.    we->VisualInfo=NULL;
  448.    we->DrawInfo=NULL;
  449.  
  450.    return(TRUE);
  451.   }
  452.  return(FALSE);
  453. }
  454.  
  455. /* ---- Fenster entikonifizieren */
  456. BOOL UnIconifyWindow(windowID)
  457.  UBYTE windowID;
  458. {
  459.  struct MultiWindowsUser *mw;
  460.  struct WindowEntry      *we;
  461.  struct RastPort         *oldRP,*newRP;
  462.  struct Node             *node;
  463.  struct MWGadget         *gad;
  464.  
  465.  USER;
  466.  we=FindWindowEntry(windowID);
  467.  if((we)&&(we->Iconify))
  468.   {
  469.    if(we->ScreenEntry!=NULL)
  470.      we->NewWindow.Screen=we->ScreenEntry->Screen;
  471.    we->Window=OpenWindow(&we->NewWindow);
  472.    if(we->Window)
  473.     {
  474.      we->Screen=we->Window->WScreen;
  475.      we->DrawInfo=GetScreenDrawInfo(we->Screen);
  476.      we->VisualInfo=GetVisualInfoA(we->Screen,NULL);
  477.      if((we->DrawInfo==NULL)||(we->VisualInfo==NULL))
  478.       {
  479.        CloseWindow(we->Window);
  480.        return(FALSE);
  481.       }
  482.  
  483.      we->Window->UserData=we;
  484.      we->Iconify=FALSE;
  485.      we->UserPort=we->Window->UserPort;
  486.  
  487.      /* --- RastPort-Kopie: von AreaPtrn bis RP_User --- */
  488.      newRP=we->Window->RPort;
  489.      oldRP=&we->IRastPort;
  490.      we->RastPort=newRP;
  491.      CopyMemQuick((ULONG)oldRP+8L,(ULONG)newRP+8L,62);
  492.      SetFont(we->RastPort,we->TextFont);
  493.  
  494.      /* --- Zeiger wiederherstellen -------------------- */
  495.      we->ViewPort=ViewPortAddress(we->Window);
  496.      we->Layer=we->Window->WLayer;
  497.      we->RastPort->TmpRas=we->TmpRas;
  498.      we->RastPort->AreaInfo=we->AreaInfo;
  499.      we->ColorMap=we->Screen->ViewPort.ColorMap;
  500.      we->Layer=we->Window->WLayer;
  501.      we->LayerInfo=&we->Screen->LayerInfo;
  502.      we->BitMap=we->Screen->RastPort.BitMap;
  503.  
  504.      we->Width=we->Window->Width;
  505.      we->Height=we->Window->Height;
  506.      we->FactorX=(FLOAT)we->Width/(FLOAT)we->OWidth;
  507.      we->FactorY=(FLOAT)we->Height/(FLOAT)we->OHeight;
  508.  
  509.      /* --- Pointer, Wallpaper, Menüs wiederherstellen - */
  510.      if(we->FirstMenu) SetMenuStrip(we->Window,we->FirstMenu);
  511.      if(we->Wallpaper) UseWallpaper(we,we->Wallpaper);
  512.      if(we->Pointer) UsePointer(we,we->Pointer);
  513.      SetPointerColors();
  514.  
  515.      /* --- Gadgets wiederherstellen ------------------- */
  516.      for(node=we->GadgetList.lh_Head;node!=&we->GadgetList.lh_Tail;node=node->ln_Succ)
  517.       {
  518.        gad=node;
  519.        gad->NewGadget.ng_VisualInfo=we->VisualInfo;
  520.        UpdateGadget(gad);
  521.       }
  522.      UpdateFrames(we,FALSE);
  523.  
  524.      if(we->Window->FirstGadget)
  525.        RefreshGList(we->Window->FirstGadget,we->Window,NULL,-1L);
  526.      RefreshSGadgets(we);
  527.      GTRefreshWindow(we->Window,NULL);
  528.  
  529.      /* ---- AppIcon entfernen ------------------------- */
  530.      if(we->AppIcon) DeleteAppObject(we->AppIcon);
  531.      if(we->AppMenuItem) DeleteAppObject(we->AppMenuItem);
  532.      we->AppIcon=NULL;
  533.      we->AppMenuItem=NULL;
  534.  
  535.      return(TRUE);
  536.     }
  537.   }
  538.  return(FALSE);
  539. }
  540.  
  541. /* ---- Fenster aktivieren */
  542. void ActWindow(windowID)
  543.  UBYTE windowID;
  544. {
  545.  struct MultiWindowsUser *mw;
  546.  struct WindowEntry      *we;
  547.  
  548.  USER;
  549.  if(windowID!=-1)
  550.   {
  551.    we=FindWindowEntry(windowID);
  552.    if(we)
  553.     {
  554.      if(we->Iconify) UnIconifyWindow(windowID);
  555.      Forbid();
  556.      mw->ActiveWindow=we;
  557.      mw->ActiveWindowID=windowID;
  558.      Permit();
  559.     }
  560.   }
  561.  else
  562.   {
  563.    mw->ActiveWindow=NULL;
  564.    mw->ActiveWindowID=-1;
  565.   }
  566. }
  567.  
  568. /* ---- Fensterdaten ermitteln */
  569. APTR GetWindowAddress(windowID)
  570.  UBYTE windowID;
  571. {
  572.  struct WindowEntry *we;
  573.  we=FindWindowEntry(windowID);
  574.  if(we) return(we->Window);
  575.  return(NULL);
  576. }
  577.  
  578. /* ---- Fensterdaten ermitteln */
  579. APTR GetWindowRastPort(windowID)
  580.  UBYTE windowID;
  581. {
  582.  struct WindowEntry *we;
  583.  we=FindWindowEntry(windowID);
  584.  if(we) return(we->RastPort);
  585.  return(NULL);
  586. }
  587.  
  588. /* ---- Fensterdaten ermitteln */
  589. APTR GetWindowWallpaper(windowID)
  590.  UBYTE windowID;
  591. {
  592.  struct WindowEntry *we;
  593.  we=FindWindowEntry(windowID);
  594.  if(we) return(we->Wallpaper);
  595.  return(NULL);
  596. }
  597.  
  598. /* ---- Fensterdaten ermitteln */
  599. APTR GetWindowWallpaperName(windowID)
  600.  UBYTE windowID;
  601. {
  602.  struct WindowEntry *we;
  603.  we=FindWindowEntry(windowID);
  604.  if((we)&&(we->Wallpaper))
  605.   {
  606.    return(we->Wallpaper->Node.ln_Name);
  607.   }
  608.  return(NULL);
  609. }
  610.  
  611. /* ---- Fensterdaten ermitteln */
  612. APTR GetWindowPointer(windowID)
  613.  UBYTE windowID;
  614. {
  615.  struct WindowEntry *we;
  616.  we=FindWindowEntry(windowID);
  617.  if(we) return(we->Pointer);
  618.  return(NULL);
  619. }
  620.  
  621. /* ---- Fensterdaten ermitteln */
  622. APTR GetWindowPointerName(windowID)
  623.  UBYTE windowID;
  624. {
  625.  struct WindowEntry *we;
  626.  we=FindWindowEntry(windowID);
  627.  if((we)&&(we->Pointer))
  628.   {
  629.    return(we->Pointer->Node.ln_Name);
  630.   }
  631.  return(NULL);
  632. }
  633.  
  634. /* ---- Fensterdaten ermitteln */
  635. APTR GetWindowScreen(windowID)
  636.  UBYTE windowID;
  637. {
  638.  struct WindowEntry *we;
  639.  we=FindWindowEntry(windowID);
  640.  if(we) return(we->Screen);
  641.  return(NULL);
  642. }
  643.  
  644. /* ---- Fensterdaten ermitteln */
  645. APTR GetWindowScreenEntry(windowID)
  646.  UBYTE windowID;
  647. {
  648.  struct WindowEntry *we;
  649.  we=FindWindowEntry(windowID);
  650.  if(we) return(we->ScreenEntry);
  651.  return(NULL);
  652. }
  653.  
  654. /* ---- Fensterdaten ermitteln */
  655. APTR GetWindowBitMap(windowID)
  656.  UBYTE windowID;
  657. {
  658.  struct WindowEntry *we;
  659.  we=FindWindowEntry(windowID);
  660.  if(we) return(we->BitMap);
  661.  return(NULL);
  662. }
  663. /* ---- Fensterdaten ermitteln */
  664. APTR GetWindowBitplane(windowID,num)
  665.  UBYTE windowID;
  666.  UBYTE num;
  667. {
  668.  struct WindowEntry *we;
  669.  we=FindWindowEntry(windowID);
  670.  if((we)&&(we->BitMap))
  671.   {
  672.    if(num<we->BitMap->Depth)
  673.      return(we->BitMap->Planes[num]);
  674.   }
  675.  return(NULL);
  676. }
  677.  
  678. /* ---- Fensterdaten ermitteln */
  679. APTR GetWindowViewPort(windowID)
  680.  UBYTE windowID;
  681. {
  682.  struct WindowEntry *we;
  683.  we=FindWindowEntry(windowID);
  684.  if(we) return(we->ViewPort);
  685.  return(NULL);
  686. }
  687.  
  688. /* ---- Fensterdaten ermitteln */
  689. APTR GetWindowLayerInfo(windowID)
  690.  UBYTE windowID;
  691. {
  692.  struct WindowEntry *we;
  693.  we=FindWindowEntry(windowID);
  694.  if(we) return(we->LayerInfo);
  695.  return(NULL);
  696. }
  697.  
  698. APTR GetWindowLayer(windowID)
  699.  UBYTE windowID;
  700. {
  701.  struct WindowEntry *we;
  702.  we=FindWindowEntry(windowID);
  703.  if(we) return(we->Layer);
  704.  return(NULL);
  705. }
  706.  
  707. /* ---- Fensterdaten ermitteln */
  708. APTR GetWindowDrawInfo(windowID)
  709.  UBYTE windowID;
  710. {
  711.  struct WindowEntry *we;
  712.  we=FindWindowEntry(windowID);
  713.  if(we) return(we->DrawInfo);
  714.  return(NULL);
  715. }
  716.  
  717. /* ---- Fensterdaten ermitteln */
  718. APTR GetWindowCMap(windowID)
  719.  UBYTE windowID;
  720. {
  721.  struct WindowEntry *we;
  722.  we=FindWindowEntry(windowID);
  723.  if(we) return(we->ColorMap);
  724.  return(NULL);
  725. }
  726.  
  727. /* ---- Fensterdaten ermitteln */
  728. APTR GetWindowCTable(windowID)
  729.  UBYTE windowID;
  730. {
  731.  struct WindowEntry *we;
  732.  we=FindWindowEntry(windowID);
  733.  if(we) return(we->ColorMap->ColorTable);
  734.  return(NULL);
  735. }
  736.  
  737. /* ---- Fensterdaten ermitteln */
  738. APTR GetWindowVisualInfo(windowID)
  739.  UBYTE windowID;
  740. {
  741.  struct WindowEntry *we;
  742.  we=FindWindowEntry(windowID);
  743.  if(we) return(we->VisualInfo);
  744.  return(NULL);
  745. }
  746.  
  747. /* ---- Fensterdaten ermitteln */
  748. APTR GetWindowUserPort(windowID)
  749.  UBYTE windowID;
  750. {
  751.  struct WindowEntry *we;
  752.  we=FindWindowEntry(windowID);
  753.  if(we) return(we->UserPort);
  754.  return(NULL);
  755. }
  756.  
  757. /* ---- Fensterdaten ermitteln */
  758. APTR GetWindowTextFont(windowID)
  759.  UBYTE windowID;
  760. {
  761.  struct WindowEntry *we;
  762.  we=FindWindowEntry(windowID);
  763.  if(we) return(we->TextFont);
  764.  return(NULL);
  765. }
  766.  
  767. /* ---- Fensterdaten ermitteln */
  768. UBYTE *GetWindowTextFontName(windowID)
  769.  UBYTE windowID;
  770. {
  771.  struct WindowEntry *we;
  772.  we=FindWindowEntry(windowID);
  773.  if(we) return(we->TextFont->tf_Message.mn_Node.ln_Name);
  774.  return(NULL);
  775. }
  776.  
  777. /* ---- Fensterdaten ermitteln */
  778. UWORD GetWindowTextFontHeight(windowID)
  779.  UBYTE windowID;
  780. {
  781.  struct WindowEntry *we;
  782.  we=FindWindowEntry(windowID);
  783.  if(we) return(we->TextFont->tf_YSize);
  784.  return(0);
  785. }
  786.  
  787. /* ---- Fensterdaten ermitteln */
  788. BOOL GetWindowIconifyStatus(windowID)
  789.  UBYTE windowID;
  790. {
  791.  struct WindowEntry *we;
  792.  we=FindWindowEntry(windowID);
  793.  if(we) return(we->Iconify);
  794.  return(TRUE);
  795. }
  796.  
  797. /* ---- Fensterdaten ermitteln */
  798. UWORD GetWindowInnerLeftEdge(windowID)
  799.  UBYTE windowID;
  800. {
  801.  struct WindowEntry *we;
  802.  we=FindWindowEntry(windowID);
  803.  if(we) return(we->InnerLeftEdge);
  804.  return(0);
  805. }
  806.  
  807. /* ---- Fensterdaten ermitteln */
  808. UWORD GetWindowInnerTopEdge(windowID)
  809.  UBYTE windowID;
  810. {
  811.  struct WindowEntry *we;
  812.  we=FindWindowEntry(windowID);
  813.  if(we) return(we->InnerTopEdge);
  814.  return(0);
  815. }
  816.  
  817. /* ---- Fensterdaten ermitteln */
  818. UWORD GetWindowInnerWidth(windowID)
  819.  UBYTE windowID;
  820. {
  821.  struct WindowEntry *we;
  822.  we=FindWindowEntry(windowID);
  823.  if(we) return(we->InnerWidth);
  824.  return(0);
  825. }
  826.  
  827. /* ---- Fensterdaten ermitteln */
  828. UWORD GetWindowInnerHeight(windowID)
  829.  UBYTE windowID;
  830. {
  831.  struct WindowEntry *we;
  832.  we=FindWindowEntry(windowID);
  833.  if(we) return(we->InnerHeight);
  834.  return(0);
  835. }
  836.  
  837. /* ---- Fensterdaten ermitteln */
  838. UWORD GetWindowWidth(windowID)
  839.  UBYTE windowID;
  840. {
  841.  struct WindowEntry *we;
  842.  we=FindWindowEntry(windowID);
  843.  if(we) return(we->Width);
  844.  return(0);
  845. }
  846.  
  847. /* ---- Fensterdaten ermitteln */
  848. UWORD GetWindowHeight(windowID)
  849.  UBYTE windowID;
  850. {
  851.  struct WindowEntry *we;
  852.  we=FindWindowEntry(windowID);
  853.  if(we) return(we->Height);
  854.  return(NULL);
  855. }
  856.  
  857. /* ---- Fensterdaten ermitteln */
  858. UWORD GetWindowOriginalWidth(windowID)
  859.  UBYTE windowID;
  860. {
  861.  struct WindowEntry *we;
  862.  we=FindWindowEntry(windowID);
  863.  if(we) return(we->OWidth);
  864.  return(0);
  865. }
  866.  
  867. /* ---- Fensterdaten ermitteln */
  868. UWORD GetWindowOriginalHeight(windowID)
  869.  UBYTE windowID;
  870. {
  871.  struct WindowEntry *we;
  872.  we=FindWindowEntry(windowID);
  873.  if(we) return(we->OHeight);
  874.  return(NULL);
  875. }
  876.  
  877. /* ---- Fensterdaten ermitteln */
  878. UWORD GetWindowLeftEdge(windowID)
  879.  UBYTE windowID;
  880. {
  881.  struct WindowEntry *we;
  882.  we=FindWindowEntry(windowID);
  883.  if(we) return(we->Window->LeftEdge);
  884.  return(0);
  885. }
  886.  
  887. /* ---- Fensterdaten ermitteln */
  888. UWORD GetWindowTopEdge(windowID)
  889.  UBYTE windowID;
  890. {
  891.  struct WindowEntry *we;
  892.  we=FindWindowEntry(windowID);
  893.  if(we) return(we->TopEdge);
  894.  return(0);
  895. }
  896.  
  897. /* ---- Fensterdaten ermitteln */
  898. FLOAT GetWindowFactorX(windowID)
  899.  UBYTE windowID;
  900. {
  901.  struct WindowEntry *we;
  902.  we=FindWindowEntry(windowID);
  903.  if(we) return(we->FactorX);
  904.  return((FLOAT)1.0);
  905. }
  906.  
  907. /* ---- Fensterdaten ermitteln */
  908. FLOAT GetWindowFactorY(windowID)
  909.  UBYTE windowID;
  910. {
  911.  struct WindowEntry *we;
  912.  we=FindWindowEntry(windowID);
  913.  if(we) return(we->FactorY);
  914.  return((FLOAT)1.0);
  915. }
  916.  
  917. /* ---- User-Info ermitteln */
  918. APTR GetUserInfo()
  919. {
  920.  return(MultiWindowsBase->UserInfo);
  921. }
  922.  
  923. /* ---- Preferences ermitteln */
  924. APTR GetPreferences()
  925. {
  926.  return(MultiWindowsBase->Preferences);
  927. }
  928.  
  929. /* ---- User-Level ermitteln */
  930. UBYTE GetUserLevel()
  931. {
  932.  return(MultiWindowsBase->UserInfo->UserLevel);
  933. }
  934.  
  935. /* ---- Fenster wird inaktiv */
  936. void InactiveWindow(we,msg,mm)
  937.  struct WindowEntry  *we;
  938.  struct IntuiMessage *msg;
  939.  struct MultiMessage *mm;
  940. {
  941.  mm->Class=MULTI_INACTIVEWINDOW;
  942.  mm->ObjectID=we->WindowID;
  943.  mm->ObjectAddress=we;
  944.  SetPointerColors();
  945. }
  946.  
  947. /* Fenster wird aktiv */
  948. void ActiveWindow(we,msg,mm)
  949.  struct WindowEntry  *we;
  950.  struct IntuiMessage *msg;
  951.  struct MultiMessage *mm;
  952. {
  953.  
  954.  UsePointer(we,we->Pointer);
  955.  mm->Class=MULTI_ACTIVEWINDOW;
  956.  mm->ObjectID=we->WindowID;
  957.  mm->ObjectAddress=we;
  958. }
  959.  
  960. /* Preferences wurden geändert */
  961. void NewPrefs(we,msg,mm)
  962.  struct WindowEntry  *we;
  963.  struct IntuiMessage *msg;
  964.  struct MultiMessage *mm;
  965. {
  966.  Forbid();
  967.  GetPrefs(&MultiWindowsBase->Preferences,sizeof(struct Preferences));
  968.  Permit();
  969.  
  970.  mm->Class=MULTI_NEWPREFS;
  971.  mm->ObjectID=we->WindowID;
  972.  mm->ObjectAddress=we;
  973. }
  974.  
  975. /* ---- Fensterdaten ermitteln */
  976. UWORD WNewX(windowID,value)
  977.  UBYTE windowID;
  978.  UWORD value;
  979. {
  980.  struct WindowEntry *we;
  981.  we=FindWindowEntry(windowID);
  982.  if(we) return(INewX(we,value));
  983.  return(value);
  984. }
  985.  
  986. /* ---- Fensterdaten ermitteln */
  987. UWORD WNewY(windowID,value)
  988.  UBYTE windowID;
  989.  UWORD value;
  990. {
  991.  struct WindowEntry *we;
  992.  we=FindWindowEntry(windowID);
  993.  if(we) return(INewY(we,value));
  994.  return(value);
  995. }
  996.  
  997. /* ---- Fensterdaten ermitteln */
  998. UWORD WNewWidth(windowID,value)
  999.  UBYTE windowID;
  1000.  UWORD value;
  1001. {
  1002.  struct WindowEntry *we;
  1003.  we=FindWindowEntry(windowID);
  1004.  if(we) return(INewWidth(we,value));
  1005.  return(value);
  1006. }
  1007.  
  1008. /* ---- Fensterdaten ermitteln */
  1009. UWORD WNewHeight(windowID,value)
  1010.  UBYTE windowID;
  1011.  UWORD value;
  1012. {
  1013.  struct WindowEntry *we;
  1014.  we=FindWindowEntry(windowID);
  1015.  if(we) return(INewHeight(we,value));
  1016.  return(value);
  1017. }
  1018.  
  1019. /* ---- Fensterdaten ermitteln */
  1020. UBYTE *GetWindowTitle(windowID)
  1021.  UBYTE windowID;
  1022. {
  1023.  struct WindowEntry *we;
  1024.  we=FindWindowEntry(windowID);
  1025.  if((we)&&(we->Window)) return(we->Window->Title);
  1026.  return(NULL);
  1027. }
  1028.  
  1029. /* ---- Fenster-Titel setzen */
  1030. void WindowTitle(windowID,title)
  1031.  UBYTE  windowID;
  1032.  UBYTE *title;
  1033. {
  1034.  struct WindowEntry *we;
  1035.  we=FindWindowEntry(windowID);
  1036.  if((we)&&(we->Window))SetWindowTitles(we->Window,title,-1L);
  1037. }
  1038.  
  1039. /* ---- Fenster-Titel setzen */
  1040. void WindowSTitle(windowID,title,stitle)
  1041.  UBYTE  windowID;
  1042.  UBYTE *title,*stitle;
  1043. {
  1044.  struct WindowEntry *we;
  1045.  we=FindWindowEntry(windowID);
  1046.  if((we)&&(we->Window)) SetWindowTitles(we->Window,title,stitle);
  1047. }
  1048.  
  1049. /* ---- Fenster aktivieren */
  1050. void WindowActivate(windowID)
  1051.  UBYTE  windowID;
  1052. {
  1053.  struct WindowEntry *we;
  1054.  we=FindWindowEntry(windowID);
  1055.  if((we)&&(we->Window)) ActivateWindow(we->Window);
  1056. }
  1057.  
  1058. /* ---- Fenster hervorholen */
  1059. void WindowFront(windowID)
  1060.  UBYTE  windowID;
  1061. {
  1062.  struct WindowEntry *we;
  1063.  we=FindWindowEntry(windowID);
  1064.  if((we)&&(we->Window)) WindowToFront(we->Window);
  1065. }
  1066.  
  1067. /* ---- Fenster nach Hinten legen */
  1068. void WindowBack(windowID)
  1069.  UBYTE  windowID;
  1070. {
  1071.  struct WindowEntry *we;
  1072.  we=FindWindowEntry(windowID);
  1073.  if((we)&&(we->Window)) WindowToBack(we->Window);
  1074. }
  1075.  
  1076. /* ---- Funktion des Zoom-Gadgets */
  1077. void WindowZoom(windowID)
  1078.  UBYTE  windowID;
  1079. {
  1080.  struct WindowEntry *we;
  1081.  we=FindWindowEntry(windowID);
  1082.  if((we)&&(we->Window)) ZipWindow(we->Window);
  1083. }
  1084.  
  1085. /* ---- Window verschieben */
  1086. void WindowMove(windowID,x,y)
  1087.  UBYTE windowID;
  1088.  WORD  x,y;
  1089. {
  1090.  struct WindowEntry *we;
  1091.  struct Window      *win;
  1092.  
  1093.  we=FindWindowEntry(windowID);
  1094.  if((we!=NULL)&&(we->Window!=NULL))
  1095.   {
  1096.    win=we->Window;
  1097.    ChangeWindowBox(we->Window,x,y,we->Window->Width,we->Window->Height);
  1098.   }
  1099. }
  1100.  
  1101. /* ---- Window verschieben */
  1102. void WindowMoveDelta(windowID,x,y)
  1103.  UBYTE windowID;
  1104.  WORD  x,y;
  1105. {
  1106.  struct WindowEntry      *we;
  1107.  struct Window           *win;
  1108.  struct MultiWindowsUser *mw;
  1109.  
  1110.  we=FindWindowEntry(windowID);
  1111.  if((we!=NULL)&&(we->Window!=NULL))
  1112.   {
  1113.    win=we->Window;
  1114.    ChangeWindowBox(we->Window,x+we->Window->LeftEdge,y+we->Window->TopEdge,we->Window->Width,we->Window->Height);
  1115.   }
  1116. }
  1117.  
  1118. /* ---- Window vergrößern/verkleinern */
  1119. void WindowSize(windowID,w,h)
  1120.  UBYTE windowID;
  1121.  WORD  w,h;
  1122. {
  1123.  struct WindowEntry      *we;
  1124.  struct Window           *win;
  1125.  struct MultiWindowsUser *mw;
  1126.  
  1127.  USER;
  1128.  w=(UWORD)((FLOAT)w*mw->FactorX);
  1129.  h=(UWORD)((FLOAT)h*mw->FactorY);
  1130.  
  1131.  we=FindWindowEntry(windowID);
  1132.  if((we!=NULL)&&(we->Window!=NULL))
  1133.   {
  1134.    win=we->Window;
  1135.    ChangeWindowBox(we->Window,we->Window->LeftEdge,we->Window->TopEdge,w,h);
  1136.   }
  1137. }
  1138.  
  1139. /* ---- Window vergrößern/verkleinern */
  1140. void WindowSizeDelta(windowID,w,h)
  1141.  UBYTE windowID;
  1142.  WORD  w,h;
  1143. {
  1144.  struct WindowEntry      *we;
  1145.  struct Window           *win;
  1146.  struct MultiWindowsUser *mw;
  1147.  
  1148.  USER;
  1149.  w=(UWORD)((FLOAT)w*mw->FactorX);
  1150.  h=(UWORD)((FLOAT)h*mw->FactorY);
  1151.  
  1152.  we=FindWindowEntry(windowID);
  1153.  if((we!=NULL)&&(we->Window!=NULL))
  1154.   {
  1155.    win=we->Window;
  1156.    ChangeWindowBox(we->Window,we->Window->LeftEdge,we->Window->TopEdge,
  1157.                    w+we->Window->Width,h+we->Window->Height);
  1158.   }
  1159. }
  1160.  
  1161. /* ---- Window vergrößern/verkleinern und verschieben */
  1162. void WindowBox(windowID,x,y,w,h)
  1163.  UBYTE windowID;
  1164.  WORD  x,y,w,h;
  1165. {
  1166.  struct WindowEntry      *we;
  1167.  struct Window           *win;
  1168.  struct MultiWindowsUser *mw;
  1169.  
  1170.  USER;
  1171.  w=(UWORD)((FLOAT)w*mw->FactorX);
  1172.  h=(UWORD)((FLOAT)h*mw->FactorY);
  1173.  
  1174.  we=FindWindowEntry(windowID);
  1175.  if((we!=NULL)&&(we->Window!=NULL))
  1176.   {
  1177.    win=we->Window;
  1178.    ChangeWindowBox(we->Window,x,y,w,h);
  1179.   }
  1180. }
  1181.  
  1182. /* ---- Fensterdaten ermitteln */
  1183. FLOAT GetWindowAspectX(windowID)
  1184.  UBYTE windowID;
  1185. {
  1186.  struct WindowEntry *we;
  1187.  we=FindWindowEntry(windowID);
  1188.  if(we) return(we->AspectX);
  1189.  return((FLOAT)1.0);
  1190. }
  1191.  
  1192. /* ---- Fensterdaten ermitteln */
  1193. FLOAT GetWindowAspectY(windowID)
  1194.  UBYTE windowID;
  1195. {
  1196.  struct WindowEntry *we;
  1197.  we=FindWindowEntry(windowID);
  1198.  if(we) return(we->AspectY);
  1199.  return((FLOAT)1.0);
  1200. }
  1201.  
  1202. /* ---- Frame erstellen */
  1203. BOOL AddFrame(id,x,y,w,h,type)
  1204.  ULONG id;
  1205.  UWORD x,y,w,h;
  1206.  UWORD type;
  1207. {
  1208.  struct WindowEntry *we;
  1209.  struct Frame       *fr;
  1210.  
  1211.  WE;
  1212.  if(we)
  1213.   {
  1214.    fr=ALLOC2(sizeof(struct Frame));
  1215.    if(fr)
  1216.     {
  1217.      fr->ID=id;
  1218.      fr->Type=type;
  1219.      fr->LeftEdge=x;
  1220.      fr->TopEdge=y;
  1221.      fr->Width=w;
  1222.      fr->Height=h;
  1223.      fr->x=0xffff;
  1224.      AddTail(&we->FrameList,fr);
  1225.      DrawFrame(we,fr,FALSE);
  1226.      return(TRUE);
  1227.     }
  1228.    else
  1229.      NoMemory();
  1230.   }
  1231.  return(FALSE);
  1232. }
  1233.  
  1234. /* ---- Frame entfernen */
  1235. void RemFrame(id)
  1236.  ULONG id;
  1237. {
  1238.  struct WindowEntry *we;
  1239.  struct Frame       *fr;
  1240.  struct MinNode     *node;
  1241.  
  1242.  WE;
  1243.  if(we)
  1244.   {
  1245.    for(node=we->FrameList.lh_Head;node!=&we->FrameList.lh_Tail;node=node->mln_Succ)
  1246.     {
  1247.      fr=node;
  1248.      if(fr->ID==id)
  1249.       {
  1250.        Remove(fr);
  1251.        FREE2(fr);
  1252.        return;
  1253.       }
  1254.     }
  1255.   } 
  1256. }
  1257.  
  1258. /* ---- Frame zeichnen */
  1259. void DrawFrame(we,fr,erase)
  1260.  struct WindowEntry *we;
  1261.  struct Frame       *fr;
  1262.  BOOL                erase;
  1263. {
  1264.  BOOL recessed,db;
  1265.  
  1266.  if(we->Iconify) return;
  1267.  
  1268.  if(!erase)
  1269.   {
  1270.    fr->x=INewX(we,fr->LeftEdge);
  1271.    fr->y=INewY(we,fr->TopEdge);
  1272.    fr->w=INewWidth(we,fr->Width);
  1273.    fr->h=INewHeight(we,fr->Height);
  1274.  
  1275.    if(fr->Type==FT_RECESSED) recessed=TRUE; else recessed=FALSE;
  1276.    if(fr->Type==FT_DOUBLE) db=TRUE; else db=FALSE;
  1277.   }
  1278.  if(fr->x!=0xffff) DrawIt(we,fr->x,fr->y,fr->w,fr->h,recessed,db,erase);
  1279. }
  1280.  
  1281. /* ---- Frames updaten */
  1282. void UpdateFrames(we,erase)
  1283.  struct WindowEntry *we;
  1284.  BOOL                erase;
  1285. {
  1286.  struct MinNode *node;
  1287.  
  1288.  for(node=we->FrameList.lh_Head;node!=&we->FrameList.lh_Tail;node=node->mln_Succ)
  1289.    DrawFrame(we,node,erase);
  1290. }
  1291.  
  1292.